home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / vectappl.cpp < prev    next >
C/C++ Source or Header  |  1994-11-04  |  14KB  |  452 lines
  1. // See Vector.h
  2. #include "vector.h"   // Vector class
  3. #include <stdio.h>
  4. #include <conio.h>
  5. #include <string.h>
  6. #include "global.h"   // Global variables
  7. #include <dos.h>
  8.  
  9. enum { SAVE = 1, DONT_SAVE };  // picture status
  10.  
  11. enum { FILE_NEW = 30, FILE_OPEN, FILE_SAVE, FILE_SAVE_AS_PCX,
  12.        FILE_SAVE_AS_PCX_BW,
  13.        SCRIPT_PLAY, SCRIPT_RECORD, SCRIPT_END, MACROS_KEEP, TEXT_EDIT };
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. //------> The following part is common for programs with SCRIPTS <---------\\
  17. void file_refresh()             // Used to get previous script name from stack
  18.     {                           // Scripts and macroses could (with some
  19.     scriptMode = GO;            // Limitations) be nested.
  20.     delete scriptFileName;
  21.     scriptFileName = NULL;
  22.     mac_status mac = macros_pop();         // Obtain previous status
  23.     delete mac.file;
  24.     }
  25. //------>    The above part is common for programs with SCRIPTS    <-------\\
  26. /////////////////////////////////////////////////////////////////////////////
  27. void Vector::to_buffer()
  28.     {
  29.     int maxx = getmaxx();
  30.     int maxy = getmaxy() - 16;
  31.     int x_screens = setup->w % maxx
  32.     ? setup->w / maxx + 1 : setup->w / maxx;
  33.     int y_screens = setup->h % maxy
  34.     ? setup->h / maxy + 1 : setup->h / maxy;
  35.     int width = x_screens * maxx + 20;
  36.     int height = y_screens * maxy + 20;
  37.  
  38.     buffer = new GrafBuffer(loc(width, height), "_work.buf",
  39.     rect(0, 0, maxx, maxy + 15));
  40.     buffer->b_open();
  41.     buffer->clear();
  42.  
  43.     int shift_x = 0;
  44.     int shift_y = 0;                            //    loc buf_dim = buffer->get_dim();
  45.     for(int i = 0; i < x_screens && !vector->get_error(); i++)
  46.     {
  47.     for(int j = 0; j < y_screens && !vector->get_error(); j++)
  48.         {
  49.         if(i || j)
  50.         vector->show();
  51.         buffer->screen_buffer();   // Copy visible part of screen
  52.         shift_y += (long)maxy;// * 100 / vector->get_add_zoom().Y;
  53.         vector->set_add_scroll(shift_x, shift_y);
  54.  
  55.         buffer->scroll(maxy, UP, 0);
  56.         }
  57.     buffer->scroll(maxy * (j - 1), DN, 0);
  58.     shift_y = 0;
  59.     shift_x += (long)maxx / 8 * 8;// * 100 / vector->get_add_zoom().X;
  60.     vector->set_add_scroll(shift_x, shift_y);
  61.     buffer->scroll(maxx / 8 * 8, LEFT, 0);
  62.     }
  63.  
  64.     vector->set_add_scroll(0, 0);
  65.     }
  66. ///////////////////////////
  67. void Vector::reload()
  68.     {
  69.     while(vector->play_used != 0)
  70.     delete vector->playpop();
  71.  
  72.     delete vector->program;
  73.  
  74.     vector->error = 0;
  75.     vector->set_program(vector->load_program(editor->getFileName()));
  76.     }
  77. ///////////////////////////
  78. // Prepare file system. Not necessary but strongly reckomended.
  79. void Vector::prepare_files()
  80.     {
  81.     delete global[1]; delete global[2];
  82.     global[1] = strdup("work"); global[2] = strdup("");
  83.     (file_sys->file_system)->setItems();
  84.     }
  85. /////////////////////////////////////////////////////////////////////////////
  86. // Board (window with PCX in it) is displayed and the simple movie is
  87. // runned in it. Icons with few fazes of demo are showed one after another.
  88. void about()
  89.     {
  90.     Board* board = new Board(rect(5, 5, 65, 20), "about.pcz",
  91.               "about.pcy", "A B O U T", 8, 0, 16);
  92.     board->show_window();
  93.  
  94.     Icon i(loc(1, 1), 2, LARGE_ICON, SHOW_BORDER);
  95.     char* file = i.icon_open();
  96.  
  97.     FILE *stream;
  98.     if((stream = fopen(file, "r+b")) == NULL)
  99.     return;
  100.     loc size = icon_size(LARGE_ICON);
  101.     int i_size = ((size.X + 1 + 7) >> 3 << 2) * (size.Y + 1) + sizeof(imageP);
  102.     imageP image = (imageP)malloc(i_size + 10);
  103.     while(1)
  104.         {
  105.         for(int j = 1; j < 17; j++)
  106.             {
  107.             get_image(stream, j, image, i_size);
  108.             putimage(screenXL(8), screenYT(10), image, COPY_PUT);
  109.             delay(20);
  110.             if(eventavail(KEYEVENT | MOUSEEVENT,
  111.                MCleftDn | MCrightDn))
  112.                 break;
  113.             }
  114.         if(eventavail(KEYEVENT | MOUSEEVENT,
  115.                MCleftDn | MCrightDn))
  116.         break;
  117.         }
  118.     get_event();
  119.     fclose(stream);
  120.     delete image;
  121.     board->hide();
  122.     delete board;
  123.     }
  124. /////////////////////////////////////////////////////////////////////////////
  125. // User-defined functions. It is good idea to write all functions, even
  126. // it they do nothing but only passes the control from one menu to another.
  127. // To know more about this topic see discussion about Simplified User
  128. // Interface in KNOW_HOW.TXT.
  129.  
  130. int Vector::application(int n)
  131.     {
  132.     rect r = vector->user_screen(); // If Block_KH_OOPic used, use
  133.                                     // (vector->vector->)user_screen()
  134.     loc mspos = e.where();          // Mouse position
  135.  
  136.     sound(100); delay(100); nosound();     // I want some beeps
  137.  
  138.     switch(n)
  139.     {
  140. //    case AC_MOVE:                  // We do not support MOVE and RESIZE
  141. //        global_i[0] = AC_MOVE;     // in this simple application.
  142. //        return 0;                  // But it is not difficult to do.
  143. //    case AC_RESIZE:                // Use KNOW-HOW.DRAW as the example.
  144. //        global_i[0] = AC_RESIZE;
  145. //        return 0;
  146.  
  147.     case AC_FILE_MENU:       // Go from line menu to the corresponding
  148.     case AC_SCRIPT_MENU:     // objects. We only pass the control here.
  149.         return 2;            // Call the next menu.
  150.     case AC_BUFFER_MENU:     // Call for Options menu
  151.             return 2;
  152.  
  153.         case AC_BUFFER:
  154.             return 1;
  155.     case AC_PRINT_MENU:      // Pass the control to the Printer setup
  156.         return 2;            // form.
  157.  
  158.     case AC_PRINT:           // Print to printer. To be changed.
  159.         editor->swap();
  160.         reload();
  161.         WindowManager::hide_window();        // Print form
  162.         rect tmp = vector->bound();
  163.         moveTo(get(vector));
  164.         //vector->set_add_zoom(1);
  165.         vector->set_add_scroll(0, 0);
  166.         WindowManager::redraw_window(rect(0, 0, getmaxx(),
  167.             getmaxy()));
  168.  
  169.         if(!vector->get_error())
  170.         {
  171.         to_buffer();
  172.         print->set_type(form->p_t);
  173.         print->set_density(form->d);
  174.         print->set_pass(form->pas);
  175.         print->set_comp(form->m_x, form->m_y, form->d_x, form->d_y);
  176.         print->set_left(form->l);
  177.         print->set_paper(form->pap);
  178.         for(int cop = 0; cop < form->cop && !vector->get_error();
  179.             cop++)
  180.                     {
  181.             print->draw_pages(buffer, "_work1.buf");
  182.             if(form->pap && getch() == 27) // Wait for char - you could
  183.                 break;                     // insert new paper
  184.                     }
  185.             buffer->b_close();
  186.                 delete buffer;
  187.                 buffer = NULL;
  188.                 }
  189.             WindowManager::redraw_window(tmp);
  190.  
  191.             moveTo(1);
  192.         menu->show();
  193.           return 0;
  194.  
  195.     case AC_NEW:             // Load empty program file.
  196.             editor->unload_file();
  197.             editor->set_swap("noname.vec");
  198.             editor->set_header("noname.vec");
  199.         editor->show();
  200.         return 1;            // Hide menu.
  201.     case AC_OPEN:
  202.         prepare_files();
  203.         (file_sys->edit)->put_string("*.vec");
  204.         DATA_FILE = FILE_OPEN;
  205.         return 2;
  206.     case AC_SAVE:
  207.         prepare_files();
  208.         (file_sys->edit)->put_string("*.vec");
  209.         DATA_FILE = FILE_SAVE;
  210.         return 2;
  211.     case AC_SAVE_AS_PCX:
  212.         prepare_files();
  213.         (file_sys->edit)->put_string("*.pcx");
  214.         DATA_FILE = FILE_SAVE_AS_PCX;
  215.         return 2;
  216.     case AC_SAVE_AS_PCX_BW:
  217.         prepare_files();
  218.         (file_sys->edit)->put_string("*.pcx");
  219.         DATA_FILE = FILE_SAVE_AS_PCX_BW;
  220.         return 2;
  221.     case AC_ABOUT:
  222.         about();
  223.         return 1;
  224.  
  225.     case AC_SCRIPT_PLAY:
  226.         DATA_FILE = SCRIPT_PLAY;
  227.         prepare_files();
  228.         (file_sys->edit)->put_string("*.sc");  // set mask for file system
  229.         return 2;
  230.     case AC_SCRIPT_RECORD:                          // recording of script
  231.         prepare_files();
  232.         DATA_FILE = SCRIPT_RECORD;
  233.         (file_sys->edit)->put_string("*.sc");
  234.         return 2;
  235.     case AC_SCRIPT_END:                        // end of script recording.
  236.         DATA_FILE = SCRIPT_END;
  237.         file_refresh();
  238.         return 1;
  239.     case AC_MACROS_KEEP:
  240.         DATA_FILE = MACROS_KEEP;
  241.  
  242.         if(scriptMode == PLAY)
  243.         {
  244.         scriptMode = GO;
  245.         return 1;
  246.         }
  247.  
  248.         file_refresh();
  249.         prepare_files();
  250.         (file_sys->edit)->put_string("*.sc");
  251.  
  252.         return 2;
  253.  
  254.     case AC_PROGRAM_EDIT:
  255.         return 2;
  256.     case AC_PROGRAM_SAVE_AND_RUN:
  257.         editor->swap();
  258.         reload();
  259.         vector->show();
  260.         sound(100); delay(100); nosound();     // I want some beeps
  261.         return 0;
  262.  
  263.     case AC_PROGRAM_RUN:
  264.             reload();
  265.         vector->show();
  266.         sound(100); delay(100); nosound();     // I want some beeps
  267.         return 0;
  268.  
  269. // Exit program.
  270.     case AC_ASK_EXIT:
  271.         return ask_exit();
  272.  
  273.     case AC_FILE:
  274.         switch(DATA_FILE)
  275.                 {
  276.                 case SCRIPT_PLAY:                          // PLAY mode
  277.                     WindowManager::hide_window();   // Hide file_sys
  278.                     WindowManager::hide_window();   // Hide file_menu
  279.  
  280.             mac_status mac;              // remember old file executed
  281.             mac.file = scriptFileName
  282.             ? strdup(scriptFileName) : NULL;
  283.             mac.ptr = scriptPtr;
  284.             mac.mode = scriptMode;
  285.  
  286.             fpos_t reserv_pos;
  287.             fgetpos(scriptPtr, &reserv_pos);
  288.             mac.pos = reserv_pos;
  289.  
  290.             macros_push(mac);        // keep it in the stack
  291.  
  292.             delete scriptFileName;
  293.             scriptFileName = global[global_i[1]]      // if file name
  294.             ? strdup(global[global_i[1]]) : NULL; // is set
  295.  
  296.             fclose(scriptPtr);
  297.             fclose(macrosPtr);
  298.  
  299.             scriptPtr = fopen(scriptFileName, "r");
  300.             macrosPtr = fopen(macrosFileName, "r");
  301.  
  302.             scriptMode = PLAY;
  303.             moveTo(1);
  304.             return 0;
  305.         case SCRIPT_RECORD:                              // RECORD
  306.                     WindowManager::hide_window();   // Hide file_sys
  307.                     WindowManager::hide_window();   // Hide file_menu
  308.  
  309.             delete scriptFileName;
  310.             scriptFileName = global[global_i[1]]
  311.             ? strdup(global[global_i[1]]) : NULL;
  312.             scriptPtr = fopen(scriptFileName, "w+");
  313.             scriptMode = RECORD;
  314.             moveTo(1);
  315.             return 0;
  316.         case SCRIPT_END:
  317.                     WindowManager::hide_window();   // Hide file_sys
  318.                     WindowManager::hide_window();   // Hide file_menu
  319.  
  320.             scriptMode = GO;
  321.             fclose(scriptPtr);
  322.                     moveTo(1);
  323.             return 0;
  324.  
  325.         case MACROS_KEEP:                   // KEEP SCRIPT AS MACROS
  326.                     WindowManager::hide_window();   // Hide file_sys
  327.                     WindowManager::hide_window();   // Hide file_menu
  328.  
  329.             int hot_result = ask_hot_key();  // (and end record before)
  330.  
  331.             if(!hot_result)             // ESC or mouse button pressed
  332.             return 0;
  333.  
  334.             scriptFileName = global[global_i[1]]
  335.             ? strdup(global[global_i[1]]) : NULL;
  336.  
  337.             fclose(scriptPtr);
  338.             fclose(macrosPtr);
  339.  
  340.             scriptPtr = fopen(scriptFileName, "r");
  341.             macrosPtr = fopen(macrosFileName, "r");
  342.  
  343.             FILE* tempPtr = fopen("temp.sc", "w");  // temp file for
  344.                                 // duplication
  345.             char command[22];
  346.             get_command(command);   // transfer e.key, set by ask_hot_key to command
  347.             add_macros(command, tempPtr);  // add the macros
  348.  
  349.             fclose(tempPtr);
  350.             fclose(macrosPtr);
  351.  
  352.             unlink(macrosFileName);                  // new macros file
  353.             rename("temp.sc", macrosFileName);
  354.             macrosPtr = fopen(macrosFileName, "r");
  355.  
  356.             init_macros();     // rebuild table of macroses
  357.  
  358.             delete scriptFileName;
  359.             scriptFileName = NULL;
  360.             moveTo(1);
  361.             return 0;
  362.  
  363.         case FILE_OPEN:
  364.             editor->unload_file();
  365.             editor->set_swap(global[global_i[1]]);
  366.             editor->set_header(global[global_i[1]]);
  367.             WindowManager::hide_window();   // Hide file_sys
  368.             WindowManager::hide_window();   // Hide file_menu
  369.             editor->show();
  370.             moveTo(get(editor));
  371.             return 0;
  372.         case FILE_SAVE:
  373.             editor->set_swap(global[global_i[1]]);
  374.             editor->set_header(global[global_i[1]]);
  375.             WindowManager::hide_window();   // Hide file_sys
  376.             WindowManager::hide_window();   // Hide file_menu
  377.             editor->swap();
  378.             editor->show();
  379.             moveTo(1);
  380.             return 0;
  381.         case FILE_SAVE_AS_PCX:
  382.         case FILE_SAVE_AS_PCX_BW:
  383.             editor->swap();
  384.             reload();
  385.             WindowManager::hide_window();   // Hide file_sys
  386.             WindowManager::hide_window();   // Hide file_menu
  387.  
  388.             rect tmp = vector->user_screen();
  389.  
  390.             moveTo(get(vector));
  391. //            vector->set_add_zoom(loc(1, 1));
  392.             vector->set_add_scroll(0, 0);
  393.             WindowManager::redraw_window(rect(0, 0, getmaxx(),
  394.             getmaxy()));
  395.  
  396.             if(setup->w <= getmaxx() && setup->h <= getmaxy())
  397.             {
  398.             if(DATA_FILE == FILE_SAVE_AS_PCX)
  399.                 pcx_scr_file(vector->user_screen(),
  400.                 global[global_i[1]], 1);
  401.             else
  402.                 {
  403.                 pcx_scr_file(vector->user_screen(),
  404.                 "tmp_0000.pcx", 1);
  405.                 pcx_col_to_bw("tmp_0000.pcx", global[global_i[1]]);
  406.                 unlink("tmp_0000.pcx");
  407.                 }
  408.             }
  409.             else
  410.             {
  411.             if(!vector->get_error())
  412.                 {
  413.                 to_buffer();
  414.                 if(DATA_FILE == FILE_SAVE_AS_PCX)
  415.                 {
  416.                 buffer->pcx_buffer_file(rect(0, 0,
  417.                     (buffer->buf_dim.X - 1) / 8 * 8 - 1,
  418.                     buffer->buf_dim.Y - 1),
  419.                     global[global_i[1]]);
  420.  
  421.                 buffer->b_close();
  422.                 }
  423.                 else
  424.                 {
  425.                 buffer->pcx_buffer_file(rect(0, 0,
  426.                     (buffer->buf_dim.X - 1) / 8 * 8 - 1,
  427.                     buffer->buf_dim.Y - 1),
  428.                 "tmp_0000.pcx");
  429.  
  430.                 buffer->b_close();
  431.                 pcx_col_to_bw("tmp_0000.pcx", global[global_i[1]]);
  432.                 unlink("tmp_0000.pcx");
  433.                 }
  434.                 delete buffer;
  435.                 buffer = NULL;
  436.                 }
  437.             }
  438.             WindowManager::redraw_window(tmp);
  439.  
  440.             moveTo(1);
  441.             return 0;
  442.         default:
  443.             return 0;
  444.         }
  445.  
  446.     default:
  447.         return 0;
  448.     }
  449.     }
  450. //////////////////////
  451.  
  452.